home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / time / RCS / Time_Multiply.c,v < prev    next >
Text File  |  1991-10-22  |  4KB  |  170 lines
  1. head     1.2;
  2. branch   ;
  3. access   ;
  4. symbols  sprited:1.2.1;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.2
  10. date     88.06.27.17.23.33;  author ouster;  state Exp;
  11. branches 1.2.1.1;
  12. next     1.1;
  13.  
  14. 1.1
  15. date     88.06.19.14.33.00;  author ouster;  state Exp;
  16. branches ;
  17. next     ;
  18.  
  19. 1.2.1.1
  20. date     91.10.22.14.50.13;  author kupfer;  state Exp;
  21. branches ;
  22. next     ;
  23.  
  24.  
  25. desc
  26. @@
  27.  
  28.  
  29. 1.2
  30. log
  31. @Use spriteTime.h instead of time.h.
  32. @
  33. text
  34. @/* 
  35.  * Time_Multiply.c --
  36.  *
  37.  *    Source code for the Time_Multiply library procedure.
  38.  *
  39.  * Copyright 1988 Regents of the University of California
  40.  * Permission to use, copy, modify, and distribute this
  41.  * software and its documentation for any purpose and without
  42.  * fee is hereby granted, provided that the above copyright
  43.  * notice appear in all copies.  The University of California
  44.  * makes no representations about the suitability of this
  45.  * software for any purpose.  It is provided "as is" without
  46.  * express or implied warranty.
  47.  */
  48.  
  49. #ifndef lint
  50. static char rcsid[] = "$Header: Time_Multiply.c,v 1.1 88/06/19 14:33:00 ouster Exp $ SPRITE (Berkeley)";
  51. #endif not lint
  52.  
  53. #include <sprite.h>
  54. #include <spriteTime.h>
  55.  
  56. /*
  57.  * OVERFLOW is used to see if multiple precision multiplication
  58.  * and division are required in the Time_Multiply  and Time_Divide routines.
  59.  * The number is equal to (2 ** 31 - 1) / 1000000.
  60.  */
  61.  
  62. #define OVERFLOW 2147
  63.  
  64. /*
  65.  *----------------------------------------------------------------------
  66.  *
  67.  * Time_Multiply --
  68.  *
  69.  *      Computes a multiple of a time value.
  70.  *    E.g. computes a time of 7 seconds given the 
  71.  *    constant time_OneSecond and a factor of 7.
  72.  *
  73.  * Results:
  74.  *     A time.
  75.  *
  76.  * Side effects:
  77.  *     None.
  78.  *
  79.  *----------------------------------------------------------------------
  80.  */
  81.  
  82. void
  83. Time_Multiply(time, factor, resultPtr)
  84.     Time time;
  85.     int     factor;
  86.     Time *resultPtr;
  87. {
  88.     register int    micro;        /* partial result */
  89.     Boolean         normalize;    /* true if normalization necessary. */
  90.  
  91.     /*
  92.      * Since floating point operations are expensive, first check if the 
  93.      * calculation can be done using cheaper integer multiplication. 
  94.      * If there is a possibility of an overflow, then resort to floating point.
  95.      *
  96.      * The test for overflow used below only tests the size of the multiplier.
  97.      * To be fair, it should test the size of time.microseconds too
  98.      * because overflow will not occur if time.microseconds is small.
  99.      * Overflow occurs when numBits(factor) + numBits(time.microseconds) > 31
  100.      * Use the easy test now because at some point in time, this section 
  101.      * should be replaced with double precision integer routines.
  102.      *
  103.      */
  104.  
  105.     normalize = FALSE;
  106.  
  107.     if (factor > OVERFLOW) {
  108.  
  109.     double realProd;
  110.  
  111.     realProd = ((double) time.seconds +
  112.             ((double) time.microseconds / (double) 1000000.0)) *
  113.             (double) factor;
  114.     resultPtr->seconds    = realProd;
  115.     resultPtr->microseconds    = ((realProd - ((double) resultPtr->seconds)) * 
  116.                      1000000.0);
  117.  
  118.     if (resultPtr->microseconds < 0) {
  119.         normalize = TRUE;
  120.     }
  121.     } else {
  122.  
  123.     /*
  124.      *  The microseconds portion is normalized such that it is < 1,000,000.
  125.      */
  126.     micro            = time.microseconds * factor;
  127.     resultPtr->seconds    = (time.seconds * factor) + (micro/ ONE_SECOND);
  128.     resultPtr->microseconds = micro % ONE_SECOND;
  129.  
  130.     if (factor < 0) {
  131.         normalize = TRUE;
  132.     } 
  133.     }
  134.  
  135.     /*
  136.      * Convert to normalized form.
  137.      *
  138.      */
  139.     if (normalize) {
  140.     resultPtr->seconds    -= 1;
  141.     resultPtr->microseconds    += ONE_SECOND;
  142.     } 
  143. }
  144. @
  145.  
  146.  
  147. 1.2.1.1
  148. log
  149. @Initial branch for Sprite server.
  150. @
  151. text
  152. @d17 1
  153. a17 1
  154. static char rcsid[] = "$Header: /sprite/src/lib/c/time/RCS/Time_Multiply.c,v 1.2 88/06/27 17:23:33 ouster Exp $ SPRITE (Berkeley)";
  155. @
  156.  
  157.  
  158. 1.1
  159. log
  160. @Initial revision
  161. @
  162. text
  163. @d17 1
  164. a17 1
  165. static char rcsid[] = "$Header: proto.c,v 1.2 88/03/11 08:39:08 ouster Exp $ SPRITE (Berkeley)";
  166. d21 1
  167. a21 1
  168. #include "time.h"
  169. @
  170.